home *** CD-ROM | disk | FTP | other *** search
/ Adobe Graphics & Publishing SDK 1996 December / Adobe Graphics & Publishing SDK 1996 December.iso / mac / After Effects 3.1 SDK Mac / Examples / UI Samples / Custom UI in comp⁄layer / AEFX_SampleUI.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-04  |  16.3 KB  |  698 lines  |  [TEXT/CWIE]
  1. /**
  2.     AEFX_SampleUI.c
  3.     
  4.     Part of the Adobe After Effects 3.1 SDK    
  5.     Copyright (c)1993-96, Adobe Systems Inc, All Rights Reserved.
  6.     
  7.     A simple After Effects plug-in with a custom user interface demonstrating
  8.     the use of PF_Cmd_Event.  UI event handling is taken care of here.
  9.  
  10.     Revision History
  11.         1.0, created by dmw
  12. **/
  13.  
  14. #include "AEFX_Sample.h"
  15.  
  16. enum {
  17.     SAM_None = 0,
  18.     SAM_Handles,
  19.     SAM_Rect
  20. };
  21.  
  22.  
  23. static void FrameFromParams (
  24.                 PF_InData        *in_data,
  25.                 PF_ParamDef        *params[],
  26.                 Rect            *frame )
  27. {
  28.     long        x_rad, y_rad, x, y;
  29.     
  30.     x_rad = FIX2INT(params[1]->u.fd.value);
  31.     y_rad = FIX2INT(params[2]->u.fd.value);
  32.     x = FIX2INT(params[3]->u.td.x_value);
  33.     y = FIX2INT(params[3]->u.td.y_value);
  34.     frame->top = y-y_rad;
  35.     frame->bottom = y+y_rad;
  36.     frame->left = x-x_rad;
  37.     frame->right = x+x_rad;
  38. }
  39.  
  40. #define OVAL_PTS                64
  41.  
  42. static     PF_FixedPoint            std_oval[OVAL_PTS];
  43.  
  44. static void InitOval (
  45.             PF_InData        *in_data,
  46.             PF_FixedPoint    *pts )
  47. {
  48.     double     rad;
  49.     short    i;
  50.     
  51.     for (i=0; i<OVAL_PTS; i++) {
  52.         rad = (2.0*i*PF_PI)/OVAL_PTS;
  53.         pts[i].x = FLOAT2FIX(PF_SIN(rad));
  54.         pts[i].y = FLOAT2FIX(PF_COS(rad));
  55.     }
  56. }
  57.  
  58.  
  59. static void TransformOval (
  60.                 PF_InData            *in_data,
  61.                 PF_FixedPoint        *corners,
  62.                 Point                *transformed )
  63. {
  64.     PF_FixedPoint        center;
  65.     PF_FpLong                angle;
  66.     PF_FpLong                dx, dy;
  67.     PF_FpLong                x_rad, y_rad;
  68.     PF_FloatMatrix            mat;
  69.     long                i;
  70.     PF_FixedPoint        copy_pts[OVAL_PTS];
  71.     
  72.     center.x = INT2FIX(corners[0].x + corners[2].x) / 2;
  73.     center.y = INT2FIX(corners[0].y + corners[2].y) / 2;
  74.  
  75.     dx = corners[1].x - corners[0].x;
  76.     dy = corners[1].y - corners[0].y;
  77.     
  78.     angle = PF_ATAN2(dy, dx);
  79.     angle /= PF_RAD_PER_DEGREE;
  80.     
  81.     x_rad = PF_SQRT(dx*dx + dy*dy) / 2.0;
  82.  
  83.     dx = corners[2].x - corners[1].x;
  84.     dy = corners[2].y - corners[1].y;
  85.     y_rad = PF_SQRT(dx*dx + dy*dy) / 2.0;
  86.  
  87.     SAM_SetIdentityMatrix(&mat);
  88.     SAM_ScaleMatrix(&mat, x_rad, y_rad, 0, 0);
  89.     SAM_RotateMatrixPlus(&mat, in_data, angle, 0, 0);
  90.  
  91.     for (i=0; i<OVAL_PTS; i++) {
  92.         copy_pts[i].x = std_oval[i].x;
  93.         copy_pts[i].y = std_oval[i].y;
  94.     }
  95.     
  96.     SAM_TransformFixPoints(&mat, OVAL_PTS, copy_pts);
  97.     
  98.     for (i=0; i<OVAL_PTS; i++) {
  99.         transformed[i].h = FIX2INT_ROUND(copy_pts[i].x + center.x);
  100.         transformed[i].v = FIX2INT_ROUND(copy_pts[i].y + center.y);
  101.     }
  102. }
  103.  
  104.  
  105. static void MyDrawOval (
  106.             PF_InData        *in_data,
  107.             PF_FixedPoint    *corners )
  108. {
  109.     Point                poly_oval[OVAL_PTS];
  110.     short                i;
  111.     TransformOval(in_data, corners, poly_oval);
  112.     
  113.     MoveTo(poly_oval[0].h, poly_oval[0].v);
  114.     
  115.     for (i=0; i<OVAL_PTS; i++) {
  116.         LineTo(poly_oval[i].h, poly_oval[i].v);
  117.     }
  118.     
  119.     LineTo(poly_oval[0].h, poly_oval[0].v);
  120.     
  121. }
  122.  
  123.  
  124. static void FixedFrameFromParams (
  125.                         PF_InData        *in_data,
  126.                         PF_ParamDef        *params[],
  127.                         PF_FixedRect    *frame )
  128. {
  129.     long x_rad, y_rad, x, y;
  130.     
  131.     x_rad = (params[1]->u.fd.value);
  132.     y_rad = (params[2]->u.fd.value);
  133.     x = (params[3]->u.td.x_value);
  134.     y = (params[3]->u.td.y_value);
  135.     frame->top = y-y_rad;
  136.     frame->bottom = y+y_rad;
  137.     frame->left = x-x_rad;
  138.     frame->right = x+x_rad;
  139. }
  140.  
  141.  
  142. static void LayerFrame2Layer (
  143.                      PF_InData            *in_data,        /* >> */
  144.                     PF_EventExtra        *extra,            /* >> */
  145.                     Point                *frame,            /* >> */
  146.                     Point                *lyr,            /* << */
  147.                     PF_FixedPoint        *fix_lyr )        /* << */
  148. {
  149.     fix_lyr->x = INT2FIX(frame->h);
  150.     fix_lyr->y = INT2FIX(frame->v);
  151.     (void)extra->cbs.frame_to_source(extra->cbs.refcon, extra->contextH, fix_lyr);
  152.     // now back into layer space
  153.     lyr->h = FIX2INT(fix_lyr->x);
  154.     lyr->v = FIX2INT(fix_lyr->y);
  155. }
  156.  
  157.  
  158. static void CompFrame2Layer (
  159.                      PF_InData            *in_data,        /* >> */
  160.                     PF_EventExtra        *extra,            /* >> */
  161.                     Point                *frame,            /* >> */
  162.                     Point                *lyr,            /* << */
  163.                     PF_FixedPoint        *fix_lyr )        /* << */
  164. {
  165.     fix_lyr->x = INT2FIX(frame->h);
  166.     fix_lyr->y = INT2FIX(frame->v);
  167.     (void)extra->cbs.frame_to_source(extra->cbs.refcon, extra->contextH, fix_lyr);
  168.     // now back into layer space
  169.     (void)extra->cbs.comp_to_layer(extra->cbs.refcon, extra->contextH, in_data->current_time, in_data->time_scale, fix_lyr);
  170.     lyr->h = FIX2INT(fix_lyr->x);
  171.     lyr->v = FIX2INT(fix_lyr->y);
  172. }
  173.  
  174.  
  175. static void Layer2CompFrame (
  176.                      PF_InData            *in_data,        /* >> */
  177.                     PF_EventExtra        *extra,            /* >> */
  178.                     Point                *layer,            /* >> */
  179.                     Point                *frame,            /* << */
  180.                     PF_FixedPoint        *fix_frame )        /* << */
  181. {
  182.     fix_frame->x = INT2FIX(layer->h);
  183.     fix_frame->y = INT2FIX(layer->v);
  184.     (void)extra->cbs.layer_to_comp(extra->cbs.refcon, extra->contextH, in_data->current_time, in_data->time_scale, fix_frame);
  185.     (void)extra->cbs.source_to_frame(extra->cbs.refcon, extra->contextH, fix_frame);
  186.     frame->h = FIX2INT(fix_frame->x);
  187.     frame->v = FIX2INT(fix_frame->y);
  188. }
  189.  
  190.  
  191. static void Layer2LayerFrame (
  192.                      PF_InData            *in_data,        /* >> */
  193.                     PF_EventExtra        *extra,            /* >> */
  194.                     Point                *layer,            /* >> */
  195.                     Point                *frame,            /* << */
  196.                     PF_FixedPoint        *fix_frame )        /* << */
  197. {
  198.     fix_frame->x = INT2FIX(layer->h);
  199.     fix_frame->y = INT2FIX(layer->v);
  200.     (void)extra->cbs.source_to_frame(extra->cbs.refcon, extra->contextH, fix_frame);
  201.     frame->h = FIX2INT(fix_frame->x);
  202.     frame->v = FIX2INT(fix_frame->y);
  203. }
  204.  
  205.  
  206. static void Source2FrameRect (
  207.                     PF_InData        *in_data,
  208.                     PF_EventExtra    *extra,
  209.                      PF_FixedRect    *fx_frame,
  210.                      PF_FixedPoint    *pts )        // array of four -> shows real bounding box
  211.                  
  212. {
  213.     short            i;
  214.     
  215.     pts[0].x = (fx_frame->left);
  216.     pts[0].y = (fx_frame->top);
  217.     
  218.     pts[1].x = (fx_frame->right);
  219.     pts[1].y = (fx_frame->top);
  220.     
  221.     pts[2].x = (fx_frame->right);
  222.     pts[2].y = (fx_frame->bottom);
  223.     
  224.     pts[3].x = (fx_frame->left);
  225.     pts[3].y = (fx_frame->bottom);
  226.     
  227.     if ((*extra->contextH)->w_type == PF_Window_COMP) {
  228.         for (i=0; i<4; i++) {
  229.             (void)extra->cbs.layer_to_comp(extra->cbs.refcon, extra->contextH, in_data->current_time, in_data->time_scale, &pts[i]);
  230.         }
  231.     }
  232.     for (i=0; i<4; i++) {
  233.         (void)extra->cbs.source_to_frame(extra->cbs.refcon, extra->contextH, &pts[i]);
  234.     }    
  235.     
  236.     fx_frame->top = pts[0].y;
  237.     fx_frame->bottom = pts[2].y;
  238.     fx_frame->left = pts[0].x;
  239.     fx_frame->right = pts[1].x;
  240. }
  241.  
  242.  
  243. static void DrawHandles (
  244.             PF_InData        *in_data,
  245.             PF_ParamDef        *params[],
  246.             PF_EventExtra    *extra )
  247. {
  248.     short            i;
  249.     Rect            box;
  250.     Rect            frame;
  251.     PF_FixedRect    fx_frame;
  252.     PF_FixedPoint    pts[4];
  253.     
  254.     FixedFrameFromParams(in_data, params, &fx_frame);
  255.     Source2FrameRect(in_data, extra, &fx_frame, pts);
  256.     
  257.     PF_FIXEDRECT_2_RECT(fx_frame, frame);
  258.  
  259.     for (i=0; i<4; i++) {
  260.         pts[i].x = FIX2INT_ROUND(pts[i].x);        
  261.         pts[i].y = FIX2INT_ROUND(pts[i].y);        
  262.     
  263.     }
  264.  
  265.     if ((*extra->contextH)->w_type == PF_Window_COMP) {
  266.         MyDrawOval(in_data, pts);
  267.         
  268.         for (i=0; i<4; i++) {
  269.             box.top = pts[i].y-3;
  270.             box.bottom = pts[i].y+3;
  271.             box.left = pts[i].x-3;
  272.             box.right = pts[i].x+3;
  273.             InvertRect(&box);
  274.         }
  275.     } else {
  276.         FrameOval(&frame);
  277.     
  278.         box.top = frame.top-3;
  279.         box.bottom = frame.top+3;
  280.         box.left = frame.left-3;
  281.         box.right = frame.left+3;
  282.         InvertRect(&box);
  283.     
  284.         box.top = frame.top-3;
  285.         box.bottom = frame.top+3;
  286.         box.left = frame.right-3;
  287.         box.right = frame.right+3;
  288.         InvertRect(&box);
  289.     
  290.         box.top = frame.bottom-3;
  291.         box.bottom = frame.bottom+3;
  292.         box.left = frame.left-3;
  293.         box.right = frame.left+3;
  294.         InvertRect(&box);
  295.     
  296.         box.top = frame.bottom-3;
  297.         box.bottom = frame.bottom+3;
  298.         box.left = frame.right-3;
  299.         box.right = frame.right+3;
  300.         InvertRect(&box);
  301.  
  302.     }    
  303. }
  304.  
  305.  
  306. static PF_Err DrawEvent (
  307.             PF_InData        *in_data,
  308.             PF_OutData        *out_data,
  309.             PF_ParamDef        *params[],
  310.             PF_LayerDef        *output,
  311.             PF_EventExtra    *event_extra )
  312. {
  313.     PF_Err            err = PF_Err_NONE;
  314.     GrafPtr            dp = (*(event_extra->contextH))->cgrafptr;
  315.     short            old_pen;
  316.     
  317.     // stuff params into globals -- we need amount & type
  318.  
  319.     if ((*event_extra->contextH)->w_type == PF_Window_LAYER ||
  320.         (*event_extra->contextH)->w_type == PF_Window_COMP) {
  321.  
  322.         old_pen = dp->pnMode;
  323.         PenMode(patXor);
  324.         DrawHandles(in_data, params, event_extra);
  325.         PenMode(old_pen);
  326.  
  327.         event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  328.         // old style:
  329.         // event_extra->handled_evt = TRUE;
  330.     }
  331.     
  332.     return err;
  333. }
  334.  
  335.  
  336. static PF_Err NewContext (
  337.             PF_InData        *in_data,
  338.             PF_OutData        *out_data,
  339.             PF_ParamDef        *params[],
  340.             PF_LayerDef        *output,
  341.             PF_EventExtra    *event_extra )
  342. {
  343.     PF_Err        err = PF_Err_NONE;
  344.     return err;
  345. }
  346.  
  347.  
  348. static Boolean DoClickHandles (
  349.                 PF_InData        *in_data,
  350.                 Rect            *frame,                    
  351.                 PF_ParamDef        *params[],
  352.                 FrameFunc        frame_func,
  353.                 PF_EventExtra    *extra )
  354. {
  355.     Boolean            done = FALSE;
  356.     Point            mouse_down;
  357.     PF_FixedPoint    mouse_layer;
  358.     Point            corners[4];
  359.     PF_FixedPoint    center;
  360.     
  361.     short            i;
  362.     long            slop;
  363.     long            hit;
  364.     
  365.     center.x = params[3]->u.td.x_value;
  366.     center.y = params[3]->u.td.y_value;
  367.  
  368.     corners[0].h = frame->left;
  369.     corners[0].v = frame->top;
  370.     
  371.     corners[1].h = frame->right;
  372.     corners[1].v = frame->top;
  373.     
  374.     corners[2].h = frame->right;
  375.     corners[2].v = frame->bottom;
  376.     
  377.     corners[3].h = frame->left;
  378.     corners[3].v = frame->bottom;
  379.     
  380.     mouse_down = extra->u.do_click.screen_point;
  381.     hit = -1;
  382.  
  383.     for (i=0; i<4; i++) {
  384.         // convert corners to comp frame
  385.         (*frame_func)(in_data, extra, &corners[i], &corners[i], &mouse_layer);
  386.         slop = ABS(corners[i].h - mouse_down.h);
  387.         slop += ABS(corners[i].v - mouse_down.v);
  388.         
  389.         if (slop < SAM_SLOP) {
  390.             hit = i;
  391.             done = TRUE;
  392.             extra->u.do_click.send_drag = TRUE;
  393.             extra->u.do_click.continue_refcon[0] = SAM_Handles;
  394.             extra->u.do_click.continue_refcon[1] = mouse_layer.x;
  395.             extra->u.do_click.continue_refcon[2] = mouse_layer.y;
  396.             extra->u.do_click.continue_refcon[3] = FALSE;                
  397.             break;
  398.         }
  399.     }    
  400.  
  401.     return done;
  402. }
  403.  
  404.  
  405. static Boolean DoDragHandles (
  406.                         PF_InData        *in_data,
  407.                         PF_ParamDef        *params[],
  408.                         FrameFunc        frame_func,
  409.                         PF_EventExtra    *extra )
  410. {
  411.     Boolean            done = FALSE;
  412.     Point            mouse_down;
  413.     PF_FixedPoint    mouse_layer;
  414.     PF_FixedPoint    center, old_center;
  415.     long            old_x, old_y;
  416.     Boolean            draw = TRUE;
  417.  
  418. // old style -- comment out this line
  419.         
  420.     if ((extra->evt_in_flags & PF_EI_DONT_DRAW) != 0) {
  421.         draw = FALSE;
  422.     }
  423.  
  424.     mouse_down = extra->u.do_click.screen_point;
  425.     (*frame_func)(in_data, extra, &mouse_down, &mouse_down, &mouse_layer);
  426.  
  427.      old_center.x = extra->u.do_click.continue_refcon[1];
  428.     old_center.y = extra->u.do_click.continue_refcon[2];
  429.     
  430.     center.x = params[3]->u.td.x_value;
  431.     center.y = params[3]->u.td.y_value;
  432.     
  433.     if (extra->u.do_click.continue_refcon[3] == FALSE) {
  434.         if (draw) DrawHandles(in_data, params, extra);        // draw new
  435.     }
  436.     old_x = params[1]->u.fd.value;
  437.     old_y = params[2]->u.fd.value;
  438.     
  439.     params[1]->u.fd.value = ABS(center.x - mouse_layer.x);
  440.     params[2]->u.fd.value = ABS(center.y - mouse_layer.y);
  441.     params[1]->changed = TRUE;
  442.     params[2]->changed = TRUE;
  443.  
  444.     if (draw) {
  445.         DrawHandles(in_data, params, extra);        // draw new
  446.         params[1]->u.fd.value = old_x;
  447.         params[2]->u.fd.value = old_y;
  448.         DrawHandles(in_data, params, extra);        // erase old
  449.         params[1]->u.fd.value = ABS(center.x - mouse_layer.x);
  450.         params[2]->u.fd.value = ABS(center.y - mouse_layer.y);
  451.     }
  452.         
  453.     done = TRUE;
  454.     extra->u.do_click.send_drag = TRUE;
  455.     extra->u.do_click.continue_refcon[0] = SAM_Handles;
  456.     extra->u.do_click.continue_refcon[1] = mouse_layer.x;
  457.     extra->u.do_click.continue_refcon[2] = mouse_layer.y;
  458.     extra->u.do_click.continue_refcon[3] = TRUE;
  459.     
  460.     if (extra->u.do_click.last_time) {
  461.         extra->u.do_click.continue_refcon[0] = 0;
  462.         extra->u.do_click.send_drag = FALSE;
  463.         if (draw) DrawHandles(in_data, params, extra);        // draw new
  464.     }
  465.     
  466.     return done;
  467.     
  468. }
  469.  
  470.  
  471. static Boolean DoClickRect (
  472.                 PF_InData        *in_data,
  473.                 Rect            *frame,
  474.                 PF_ParamDef        *params[],
  475.                 FrameFunc        frame_func,
  476.                 PF_EventExtra    *extra )
  477. {
  478.     Boolean            done = FALSE;
  479.     Point            mouse_down;
  480.     PF_FixedPoint    mouse_layer;
  481.  
  482.     mouse_down = extra->u.do_click.screen_point;
  483.     (*frame_func)(in_data, extra, &mouse_down, &mouse_down, &mouse_layer);
  484.     
  485.     if (PtInRect(mouse_down, frame)) {
  486.         done = TRUE;
  487.         extra->u.do_click.send_drag = TRUE;
  488.         extra->u.do_click.continue_refcon[0] = SAM_Rect;
  489.         extra->u.do_click.continue_refcon[1] = mouse_layer.x;
  490.         extra->u.do_click.continue_refcon[2] = mouse_layer.y;
  491.         extra->u.do_click.continue_refcon[3] = FALSE;
  492.  
  493.     }
  494.     
  495.     return done;
  496. }
  497.  
  498.  
  499. static Boolean DoDragRect (
  500.                     PF_InData        *in_data,
  501.                     PF_ParamDef        *params[],
  502.                     FrameFunc        frame_func,
  503.                     PF_EventExtra    *extra )
  504. {
  505.     Boolean            done = FALSE;
  506.     Point            mouse_down;
  507.     PF_FixedPoint    mouse_layer;
  508.     PF_FixedPoint    d;
  509.     Boolean            draw = TRUE;
  510.  
  511. // old style -- comment out this line
  512.     
  513.     if ((extra->evt_in_flags & PF_EI_DONT_DRAW) != 0) {
  514.         draw = FALSE;
  515.     }
  516.  
  517.     mouse_down = extra->u.do_click.screen_point;
  518.     (*frame_func)(in_data, extra, &mouse_down, &mouse_down, &mouse_layer);
  519.  
  520.     d.x = mouse_layer.x - extra->u.do_click.continue_refcon[1];
  521.     d.y = mouse_layer.y - extra->u.do_click.continue_refcon[2];
  522.     
  523.     if (extra->u.do_click.continue_refcon[3] == FALSE) {
  524.         if (draw)
  525.             DrawHandles(in_data, params, extra);        // draw new
  526.     }
  527.     params[3]->u.td.x_value += (d.x);
  528.     params[3]->u.td.y_value += (d.y);
  529.     params[3]->changed = TRUE;
  530.  
  531.     if (draw) {
  532.         DrawHandles(in_data, params, extra);        // draw new
  533.         params[3]->u.td.x_value -= (d.x);
  534.         params[3]->u.td.y_value -= (d.y);
  535.         DrawHandles(in_data, params, extra);        // erase old
  536.         params[3]->u.td.x_value += (d.x);
  537.         params[3]->u.td.y_value += (d.y);
  538.     }
  539.         
  540.     done = TRUE;
  541.     extra->u.do_click.send_drag = TRUE;
  542.     extra->u.do_click.continue_refcon[0] = SAM_Rect;
  543.     extra->u.do_click.continue_refcon[1] = mouse_layer.x;
  544.     extra->u.do_click.continue_refcon[2] = mouse_layer.y;
  545.     extra->u.do_click.continue_refcon[3] = TRUE;
  546.     
  547.     if (extra->u.do_click.last_time) {
  548.         extra->u.do_click.continue_refcon[0] = 0;
  549.         extra->u.do_click.send_drag = FALSE;
  550.         if (draw) DrawHandles(in_data, params, extra);        // draw new
  551.     }
  552.     
  553.     return done;
  554.     
  555. }
  556.  
  557.  
  558. static PF_Err DoClick (
  559.             PF_InData        *in_data,
  560.             PF_OutData        *out_data,
  561.             PF_ParamDef        *params[],
  562.             PF_LayerDef        *output,
  563.             PF_EventExtra    *event_extra )
  564. {
  565.     PF_Err         err = PF_Err_NONE;
  566.     PF_ContextH    contextH = event_extra->contextH;
  567.     GrafPtr        dp = (*(event_extra->contextH))->cgrafptr;
  568.     Rect        frame;
  569.     short        oldPat = dp->pnMode;
  570.     
  571.     FrameFromParams(in_data, params, &frame);
  572.     PenMode(patXor);
  573.  
  574.     if ((*contextH)->w_type == PF_Window_LAYER) {
  575.         if (DoClickHandles(in_data, &frame, params, Layer2LayerFrame, event_extra)) {
  576.             event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  577.         } else if (DoClickRect(in_data, &frame, params, LayerFrame2Layer, event_extra)) {
  578.             event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  579.         }
  580.         
  581.     } else if ((*contextH)->w_type == PF_Window_COMP) {
  582.         if (DoClickHandles(in_data, &frame, params, Layer2CompFrame, event_extra)) {
  583.             event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  584.         } else if (DoClickRect(in_data, &frame, params, CompFrame2Layer, event_extra)) {
  585.             event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  586.         }
  587.     }
  588.  
  589.     PenMode(oldPat);
  590.     
  591.     return err;
  592. }
  593.  
  594.  
  595. static PF_Err DoDrag (
  596.             PF_InData        *in_data,
  597.             PF_OutData        *out_data,
  598.             PF_ParamDef        *params[],
  599.             PF_LayerDef        *output,
  600.             PF_EventExtra    *event_extra )
  601. {
  602.     PF_Err                     err = PF_Err_NONE;
  603.     PF_ContextH                contextH = event_extra->contextH;
  604.     PF_DoClickEventInfo     do_click;
  605.     GrafPtr                    dp = (*(event_extra->contextH))->cgrafptr;
  606.     Rect                    frame;
  607.     short                    oldPat = dp->pnMode;
  608.     FrameFunc                frame_func = NULL;
  609.     
  610.     FrameFromParams(in_data, params, &frame);
  611.     PenMode(patXor);
  612.  
  613.     do_click = event_extra->u.do_click;
  614.     
  615.     if ((*contextH)->w_type == PF_Window_LAYER) {
  616.         frame_func = LayerFrame2Layer;
  617.     } else if ((*contextH)->w_type == PF_Window_COMP) {
  618.         frame_func = CompFrame2Layer;
  619.     }
  620.     
  621.     if (frame_func) {
  622.         switch (do_click.continue_refcon[0]) {
  623.             
  624.             case SAM_Rect:
  625.                 DoDragRect(in_data, params, frame_func, event_extra);
  626.                 event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  627.                 // old style:
  628.                 // event_extra->handled_evt = TRUE;
  629.                 break;
  630.             
  631.             case SAM_Handles:
  632.                 DoDragHandles(in_data, params, frame_func, event_extra);
  633.                 event_extra->evt_out_flags = PF_EO_HANDLED_EVENT;
  634.                 // old style:
  635.                 // event_extra->handled_evt = TRUE;
  636.                 break;
  637.         }
  638.     }
  639.     
  640.     PenMode(oldPat);
  641.     
  642.     return err;
  643. }
  644.  
  645.  
  646. PF_Err HandleEvent (
  647.     PF_InData        *in_data,
  648.     PF_OutData        *out_data,
  649.     PF_ParamDef        *params[],
  650.     PF_LayerDef        *output,
  651.     PF_EventExtra    *event_extra )
  652. {
  653.     PF_Err        err = PF_Err_NONE;
  654.  
  655.     if (event_extra->e_type == PF_Event_DO_CLICK) {
  656.         if (event_extra->u.do_click.send_drag) event_extra->e_type = PF_Event_DRAG;
  657.     }
  658.  
  659.     switch (event_extra->e_type) {
  660.  
  661.         case PF_Event_NEW_CONTEXT:
  662.             InitOval(in_data, std_oval);
  663.             NewContext(in_data, out_data, params, output, event_extra);
  664.             break;
  665.             
  666.         case PF_Event_ACTIVATE:
  667.             break;
  668.         
  669.         case PF_Event_DO_CLICK:
  670.             DoClick(in_data, out_data, params, output, event_extra);
  671.             break;
  672.         
  673.         case PF_Event_DRAG:
  674.             DoDrag(in_data, out_data, params, output, event_extra);
  675.             break;
  676.         
  677.         case PF_Event_DRAW:
  678.             DrawEvent(in_data, out_data, params, output, event_extra);
  679.             break;
  680.         
  681.         case PF_Event_DEACTIVATE:
  682.             break;
  683.         
  684.         case PF_Event_CLOSE_CONTEXT:
  685.             break;
  686.         
  687.         case PF_Event_IDLE:
  688.             break;
  689.         
  690.         default:
  691.             DebugStr("\p Unknown event");
  692.             break;
  693.         
  694.     }
  695.     
  696.     return err;
  697. }
  698.